{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://raw.githubusercontent.com/Qiskit/qiskit-tutorials/master/images/qiskit-heading.png\" alt=\"Note: In order for images to show up in this jupyter notebook you need to select File => Trusted Notebook\" width=\"500 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Randomized Benchmarking Overview\n",
    "\n",
    "### Contributors\n",
    "\n",
    "Shelly Garion$^{1}$, Yael Ben-Haim$^{1}$, Naoki Kanazawa$^{2}$ and David McKay$^{3}$\n",
    "\n",
    "1. IBM Research Haifa, Haifa University Campus, Mount Carmel Haifa, Israel\n",
    "2. IBM Research Tokyo, Hakozaki-cho, Chuo-ku, Tokyo, Japan\n",
    "3. IBM T.J. Watson Research Center, Yorktown Heights, NY, USA\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "One of the main challenges in building a quantum information processor is the non-scalability of completely\n",
    "characterizing the noise affecting a quantum system via process tomography. In addition, process tomography is sensitive to noise in the pre- and post rotation gates plus the measurements (SPAM errors). Gateset tomography can take these errors into account, but the scaling is even worse.  A complete characterization\n",
    "of the noise is useful because it allows for  the determination of good error-correction schemes, and thus\n",
    "the possibility of reliable transmission of quantum information.\n",
    "\n",
    "Since complete process tomography is infeasible for large systems, there is growing interest in scalable\n",
    "methods for partially characterizing the noise affecting a quantum system. A scalable (in the number $n$ of qubits comprising the system) and robust algorithm for benchmarking the full set of Clifford gates by a single parameter using randomization techniques was presented in [1]. The concept of using randomization methods for benchmarking quantum gates is commonly called **Randomized Benchmarking\n",
    "(RB)**.\n",
    "\n",
    "\n",
    "### References\n",
    "\n",
    "1. Easwar Magesan, J. M. Gambetta, and Joseph Emerson, *Robust randomized benchmarking of quantum processes*,\n",
    "https://arxiv.org/pdf/1009.3639\n",
    "\n",
    "2. Easwar Magesan, Jay M. Gambetta, and Joseph Emerson, *Characterizing Quantum Gates via Randomized Benchmarking*,\n",
    "https://arxiv.org/pdf/1109.6887\n",
    "\n",
    "3. A. D. C'orcoles, Jay M. Gambetta, Jerry M. Chow, John A. Smolin, Matthew Ware, J. D. Strand, B. L. T. Plourde, and M. Steffen, *Process verification of two-qubit quantum gates by randomized benchmarking*, https://arxiv.org/pdf/1210.7011\n",
    "\n",
    "4. Jay M. Gambetta, A. D. C´orcoles, S. T. Merkel, B. R. Johnson, John A. Smolin, Jerry M. Chow,\n",
    "Colm A. Ryan, Chad Rigetti, S. Poletto, Thomas A. Ohki, Mark B. Ketchen, and M. Steffen,\n",
    "*Characterization of addressability by simultaneous randomized benchmarking*, https://arxiv.org/pdf/1204.6308\n",
    "\n",
    "5. David C. McKay, Sarah Sheldon, John A. Smolin, Jerry M. Chow, and Jay M. Gambetta, *Three Qubit Randomized Benchmarking*, https://arxiv.org/pdf/1712.06550"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Randomized Benchmarking Protocol\n",
    "\n",
    "A RB protocol (see [1,2]) consists of the following steps:\n",
    "\n",
    "(We should first import the relevant qiskit classes for the demonstration)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Import general libraries (needed for functions)\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython import display\n",
    "\n",
    "#Import the RB Functions\n",
    "import qiskit.ignis.verification.randomized_benchmarking as rb\n",
    "\n",
    "#Import Qiskit classes \n",
    "import qiskit\n",
    "from qiskit.providers.aer.noise import NoiseModel\n",
    "from qiskit.providers.aer.noise.errors.standard_errors import depolarizing_error, thermal_relaxation_error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 1: Generate RB sequences\n",
    "\n",
    "The RB sequences consist of random Clifford elements chosen uniformly from the Clifford group on $n$-qubits, \n",
    "including a computed reversal element,\n",
    "that should return the qubits to the initial state.\n",
    "\n",
    "More precisely, for each length $m$, we choose $K_m$ RB sequences. \n",
    "Each such sequence contains $m$ random elements $C_{i_j}$ chosen uniformly from the Clifford group on $n$-qubits, and the $m+1$ element is defined as follows: $C_{i_{m+1}} = (C_{i_1}\\cdot ... \\cdot C_{i_m})^{-1}$. It can be found efficiently by the Gottesmann-Knill theorem.\n",
    "\n",
    "For example, we generate below several sequences of 2-qubit Clifford circuits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Generate RB circuits (2Q RB)\n",
    "\n",
    "#number of qubits\n",
    "nQ=2 \n",
    "rb_opts = {}\n",
    "#Number of Cliffords in the sequence\n",
    "rb_opts['length_vector'] = [1, 10, 20, 50, 75, 100, 125, 150, 175, 200]\n",
    "#Number of seeds (random sequences)\n",
    "rb_opts['nseeds'] = 5 \n",
    "#Default pattern\n",
    "rb_opts['rb_pattern'] = [[0,1]]\n",
    "\n",
    "rb_circs, xdata = rb.randomized_benchmarking_seq(**rb_opts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As an example, we print the circuit corresponding to the first RB sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         ┌───┐┌───┐┌───┐     ┌───┐┌───┐      ░ ┌─────┐ ┌───┐           ┌─────┐»\n",
      "qr_0: |0>┤ H ├┤ H ├┤ S ├──■──┤ H ├┤ S ├──────░─┤ Sdg ├─┤ H ├────────■──┤ Sdg ├»\n",
      "         ├───┤├───┤├───┤┌─┴─┐├───┤├───┤┌───┐ ░ └┬───┬┘┌┴───┴┐┌───┐┌─┴─┐├─────┤»\n",
      "qr_1: |0>┤ H ├┤ H ├┤ S ├┤ X ├┤ H ├┤ S ├┤ X ├─░──┤ X ├─┤ Sdg ├┤ H ├┤ X ├┤ Sdg ├»\n",
      "         └───┘└───┘└───┘└───┘└───┘└───┘└───┘ ░  └───┘ └─────┘└───┘└───┘└─────┘»\n",
      " cr_0: 0 ═════════════════════════════════════════════════════════════════════»\n",
      "                                                                              »\n",
      " cr_1: 0 ═════════════════════════════════════════════════════════════════════»\n",
      "                                                                              »\n",
      "«      ┌───┐┌───┐┌─┐   \n",
      "«qr_0: ┤ H ├┤ H ├┤M├───\n",
      "«      ├───┤├───┤└╥┘┌─┐\n",
      "«qr_1: ┤ H ├┤ H ├─╫─┤M├\n",
      "«      └───┘└───┘ ║ └╥┘\n",
      "«cr_0: ═══════════╩══╬═\n",
      "«                    ║ \n",
      "«cr_1: ══════════════╩═\n",
      "«                      \n"
     ]
    }
   ],
   "source": [
    "print(rb_circs[0][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can verify that the Unitary representing each RB circuit should be the identity (with a global phase). \n",
    "We simulate this using Aer unitary simulator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a new circuit without the measurement\n",
    "qregs = rb_circs[0][-1].qregs\n",
    "cregs = rb_circs[0][-1].cregs\n",
    "qc = qiskit.QuantumCircuit(*qregs, *cregs)\n",
    "for i in rb_circs[0][-1][0:-nQ]:\n",
    "    qc.data.append(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.-1.j  0.+0.j -0.-0.j  0.+0.j]\n",
      " [ 0.+0.j -0.-1.j  0.+0.j -0.+0.j]\n",
      " [ 0.+0.j  0.-0.j -0.-1.j -0.-0.j]\n",
      " [ 0.-0.j  0.-0.j -0.+0.j -0.-1.j]]\n"
     ]
    }
   ],
   "source": [
    "# The Unitary is an identity (with a global phase)\n",
    "backend = qiskit.Aer.get_backend('unitary_simulator')\n",
    "basis_gates = ['u1','u2','u3','cx'] # use U,CX for now\n",
    "job = qiskit.execute(qc, backend=backend, basis_gates=basis_gates)\n",
    "print(np.around(job.result().get_unitary(),3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 2: Execute the RB sequences (with some noise)\n",
    "\n",
    "We can execute the RB sequences either using Qiskit Aer Simulator (with some noise model) or using IBMQ provider, and obtain a list of results.\n",
    "\n",
    "By assumption each operation $C_{i_j}$ is allowed to have some error, represnted by $\\Lambda_{i_j,j}$, and each sequence can be modeled by the operation:\n",
    "$$\\textit{S}_{\\textbf{i}_\\textbf{m}} = \\bigcirc_{j=1}^{m+1} (\\Lambda_{i_j,j} \\circ C_{i_j})$$\n",
    "where ${\\textbf{i}_\\textbf{m}} = (i_1,...,i_m)$ and $i_{m+1}$ is uniquely determined by ${\\textbf{i}_\\textbf{m}}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run on a noisy simulator\n",
    "noise_model = NoiseModel()\n",
    "# Depolarizing error on the gates u2, u3 and cx\n",
    "p1Q = 0.002\n",
    "p2Q = 0.01\n",
    "noise_model.add_all_qubit_quantum_error(depolarizing_error(p1Q, 1), 'u2')\n",
    "noise_model.add_all_qubit_quantum_error(depolarizing_error(2*p1Q, 1), 'u3')\n",
    "noise_model.add_all_qubit_quantum_error(depolarizing_error(p2Q, 2), 'cx')\n",
    "\n",
    "backend = qiskit.Aer.get_backend('qasm_simulator')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 3: Get statistics about the survival probabilities\n",
    "\n",
    "For each of the $K_m$ sequences the survival probability $Tr[E_\\psi \\textit{S}_{\\textbf{i}_\\textbf{m}}(\\rho_\\psi)]$\n",
    "is measured. \n",
    "Here $\\rho_\\psi$ is the initial state taking into account preparation errors and $E_\\psi$ is the\n",
    "POVM element that takes into account measurement errors.\n",
    "In the ideal (noise-free) case $\\rho_\\psi = E_\\psi = | \\psi {\\rangle} {\\langle} \\psi |$. \n",
    "\n",
    "In practice one can measure the probability to go back to the exact initial state, i.e. all the qubits in the ground state $ {|} 00...0 {\\rangle}$ or just the probability for one of the qubits to return back to the ground state. Measuring the qubits independently can be more convenient if a correlated measurement scheme is not possible. Both measurements will fit to the same decay parameter according to the properties of the *twirl*. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 4: Find the averaged sequence fidelity\n",
    "\n",
    "Average over the $K_m$ random realizations of the sequence to find the averaged sequence **fidelity**,\n",
    "$$F_{seq}(m,|\\psi{\\rangle}) = Tr[E_\\psi \\textit{S}_{K_m}(\\rho_\\psi)]$$\n",
    "where \n",
    "$$\\textit{S}_{K_m} = \\frac{1}{K_m} \\sum_{\\textbf{i}_\\textbf{m}} \\textit{S}_{\\textbf{i}_\\textbf{m}}$$\n",
    "is the average sequence operation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 5: Fit the results\n",
    "\n",
    "Repeat Steps 1 through 4 for different values of $m$ and fit the results for the averaged sequence fidelity to the model:\n",
    "$$ \\textit{F}_{seq}^{(0)} \\big(m,{|}\\psi {\\rangle} \\big) = A_0 \\alpha^m +B_0$$\n",
    "where $A_0$ and $B_0$ absorb state preparation and measurement errors as well as an edge effect from the\n",
    "error on the final gate.\n",
    "\n",
    "$\\alpha$ determines the average error-rate $r$, which is also called **Error per Clifford (EPC)** \n",
    "according to the relation $$ r = 1-\\alpha-\\frac{1-\\alpha}{2^n} = \\frac{2^n-1}{2^n}(1-\\alpha)$$\n",
    "(where $n=nQ$ is the number of qubits).\n",
    "\n",
    "As an example, we calculate the average sequence fidelity for each of the RB sequences, fit the results to the exponential curve, and compute the paraemters $\\alpha$ and EPC."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compiling seed 0\n",
      "Simulating seed 0\n",
      "After seed 0, alpha: 0.979619, EPC: 0.015285\n",
      "Compiling seed 1\n",
      "Simulating seed 1\n",
      "After seed 1, alpha: 0.978386, EPC: 0.016211\n",
      "Compiling seed 2\n",
      "Simulating seed 2\n",
      "After seed 2, alpha: 0.980224, EPC: 0.014832\n",
      "Compiling seed 3\n",
      "Simulating seed 3\n",
      "After seed 3, alpha: 0.978546, EPC: 0.016090\n",
      "Compiling seed 4\n",
      "Simulating seed 4\n",
      "After seed 4, alpha: 0.977678, EPC: 0.016742\n"
     ]
    }
   ],
   "source": [
    "# Create the RB fitter\n",
    "backend = qiskit.Aer.get_backend('qasm_simulator')\n",
    "basis_gates = ['u1','u2','u3','cx'] \n",
    "shots = 200\n",
    "transpiled_circs_list = []\n",
    "rb_fit = rb.RBFitter(None, xdata, rb_opts['rb_pattern'])\n",
    "for rb_seed, rb_circ_seed in enumerate(rb_circs):\n",
    "    print('Compiling seed %d'%rb_seed)\n",
    "    new_rb_circ_seed = qiskit.compiler.transpile(rb_circ_seed, basis_gates=basis_gates)\n",
    "    transpiled_circs_list.append(new_rb_circ_seed)\n",
    "    job = qiskit.execute(new_rb_circ_seed, backend, shots=shots,\n",
    "                         noise_model=noise_model,\n",
    "                         backend_options={'max_parallel_experiments': 0})\n",
    "    print('Simulating seed %d'%rb_seed)\n",
    "    # Add data to the fitter\n",
    "    rb_fit.add_data(job.result())\n",
    "    print('After seed %d, alpha: %f, EPC: %f'%(rb_seed,rb_fit.fit[0]['params'][1], rb_fit.fit[0]['epc']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 6))\n",
    "ax = plt.subplot(1, 1, 1)\n",
    "\n",
    "# Plot the essence by calling plot_rb_data\n",
    "rb_fit.plot_rb_data(0, ax=ax, add_label=True, show_plt=False)\n",
    "    \n",
    "# Add title and label\n",
    "ax.set_title('%d Qubit RB'%(nQ), fontsize=18)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The intuition behind RB\n",
    "\n",
    "The depolarizing quantum channel has a parameter $\\alpha$, and works like this: with probability $\\alpha$, the state remains the same as before; with probability $1-\\alpha$, the state becomes the totally mixed state, namely:\n",
    "\n",
    "$$\\rho_f = \\alpha \\rho_i + \\frac{1-\\alpha}{2^n} * \\mathbf{I}$$\n",
    "\n",
    "Suppose that we have a sequence of $m$ gates, not necessarily Clifford gates, \n",
    "where the error channel of the gates is a depolarizing channel with parameter $\\alpha$ \n",
    "(same $\\alpha$ for all the gates). \n",
    "Then with probability $\\alpha^m$ the state is correct at the end of the sequence, \n",
    "and with probability $1-\\alpha^m$ it becomes the totally mixed state, therefore:\n",
    "\n",
    "$$\\rho_f^m = \\alpha^m \\rho_i + \\frac{1-\\alpha^m}{2^n} * \\mathbf{I}$$\n",
    "\n",
    "Now suppose that in addition we start with the ground state; \n",
    "that the entire sequence amounts to the identity; \n",
    "and that we measure the state at the end of the sequence with the standard basis. \n",
    "We derive that the probability of success at the end of the sequence is:\n",
    "\n",
    "$$\\alpha^m + \\frac{1-\\alpha^m}{2^n} = \\frac{2^n-1}{2^n}\\alpha^m + \\frac{1}{2^n} =  A_0\\alpha^m + B_0$$\n",
    "\n",
    "It follows that the probability of success, aka fidelity, decays exponentially with the sequence length, with exponent $\\alpha$.\n",
    "\n",
    "The last statement is not necessarily true when the channel is other than the depolarizing channel. However, it turns out that if the gates are uniformly-randomized Clifford gates, then the noise of each gate behaves on average as if it was the depolarizing channel, with some parameter that can be computed from the channel, and we obtain the exponential decay of the fidelity.\n",
    "\n",
    "Formally, taking an average over a finite group $G$ (like the Clifford group) of a quantum channel $\\bar \\Lambda$ is also called a *twirl*:\n",
    "$$ W_G(\\bar \\Lambda) \\frac{1}{|G|} \\sum_{u \\in G} U^{\\dagger} \\circ  \\bar \\Lambda \\circ U$$\n",
    "Twirling over the entire unitary group yields exactly the same result as the Clifford group. The Clifford group is a *2-design* of the unitary group."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simultaneous Randomized Benchmarking\n",
    "\n",
    "\n",
    "RB is designed to address fidelities in multiqubit systems in two ways. For one, RB over the full $n$-qubit space\n",
    "can be performed by constructing sequences from the $n$-qubit Clifford group. Additionally, the $n$-qubit space\n",
    "can be subdivided into sets of qubits $\\{n_i\\}$ and $n_i$-qubit RB performed in each subset simultaneously [4]. \n",
    "Both methods give metrics of fidelity in the $n$-qubit space. \n",
    "\n",
    "For example, it is common to perform 2Q RB on the subset of two-qubits defining a CNOT gate while the other qubits are quiescent. As explained in [4], this RB data will not necessarily decay exponentially because the other qubit subspaces are not twirled. Subsets are more rigorously characterized by simultaneous RB, which also measures some level of crosstalk error since all qubits are active.\n",
    "\n",
    "An example of simultaneous RB (1Q RB and 2Q RB) can be found in: \n",
    "https://github.com/Qiskit/qiskit-tutorials/blob/master/qiskit/ignis/randomized_benchmarking.ipynb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predicted Gate Fidelity\n",
    "\n",
    "If we know the errors on the underlying gates (the gateset) we can predict the error per Clifford (EPC) without running RB experiment. First we need to count the number of these gates per Clifford. \n",
    "\n",
    "Then, the two qubit Clifford gate error function `calculate_2q_epc` gives the estimate of error per 2Q Clifford. It assumes that the error in the underlying gates is depolarizing. This function is derived in the supplement to [5]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of u1 gates per Clifford: 0.270742\n",
      "Number of u2 gates per Clifford: 0.919105\n",
      "Number of u3 gates per Clifford: 0.499017\n",
      "Number of cx gates per Clifford: 1.491485\n"
     ]
    }
   ],
   "source": [
    "# count the number of single and 2Q gates in the 2Q Cliffords\n",
    "qubits = rb_opts['rb_pattern'][0]\n",
    "gate_per_cliff = rb.rb_utils.gates_per_clifford(transpiled_circuits_list=transpiled_circs_list,\n",
    "                                                 clifford_lengths=xdata[0],\n",
    "                                                 basis=basis_gates,\n",
    "                                                 qubits=qubits)\n",
    "\n",
    "for basis_gate in basis_gates:\n",
    "    print(\"Number of %s gates per Clifford: %f\"%(basis_gate,\n",
    "                                                 np.mean([gate_per_cliff[qubit][basis_gate] for qubit in qubits])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted 2Q Error per Clifford: 1.568297e-02 (qasm simulator: 1.674174e-02)\n"
     ]
    }
   ],
   "source": [
    "# convert from depolarizing error to epg (1Q)\n",
    "epg_q0 = {'u1': 0, 'u2': p1Q/2, 'u3': 2 * p1Q/2}\n",
    "epg_q1 = {'u1': 0, 'u2': p1Q/2, 'u3': 2 * p1Q/2}\n",
    "# convert from depolarizing error to epg (2Q)\n",
    "epg_q01 = 3/4 * p2Q\n",
    "\n",
    "# calculate the predicted epc\n",
    "pred_epc = rb.rb_utils.calculate_2q_epc(gate_per_cliff=gate_per_cliff, epg_2q=epg_q01,\n",
    "                                        qubit_pair=qubits, list_epgs_1q=[epg_q0, epg_q1])\n",
    "\n",
    "print(\"Predicted 2Q Error per Clifford: %e (qasm simulator: %e)\" % (pred_epc, rb_fit.fit[0]['epc']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given that we know the errors on the single qubit gateset, we can predict 2Q gate error from the EPC of two qubit RB experiment. The two qubit gate error function `calculate_2q_epg` gives the estimate of error per 2Q gate. In this tutorial, we prepare 1Q EPGs of each qubit using the deporalizing error model. In the experiment, EPG of each single qubit gateset (eg. `[u1, u2, u3]`) can be estimated with 1Q RB experiment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted 2Q Error per gate: 8.195786e-03 (model: 7.500000e-03)\n"
     ]
    }
   ],
   "source": [
    "# use 2Q EPC from qasm simulator and 1Q EPGs from depolarizing error\n",
    "pred_epg = rb.rb_utils.calculate_2q_epg(gate_per_cliff=gate_per_cliff, epc_2q=rb_fit.fit[0]['epc'],\n",
    "                                        qubit_pair=qubits, list_epgs_1q=[epg_q0, epg_q1])\n",
    "\n",
    "print(\"Predicted 2Q Error per gate: %e (model: %e)\" % (pred_epg, epg_q01))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
